import { createRouter, createWebHistory } from 'vue-router';
import store from '@/store';
import { generateRoutesFromMenus } from './menuRoutes';

const routes = [
  {
    path: '/',
    redirect: '/login',
  },
  {
    path: '/login',
    name: 'login',
    component: () => import('@/views/Login'),
  },
  {
    path: '/homepage',
    name: 'HomePage',
    component: () => import('@/views/HomePage'),
    children: [
      // 子路由将根据菜单动态添加
    ],
  },
  {
    path: '/about',
    name: 'about',
    // route level code-splitting
    // this generates a separate chunk (about.[hash].js) for this route
    // which is lazy-loaded when the route is visited.
    // component: () => import(/* webpackChunkName: "about" */ '../views/AboutView.vue')
  },
];

const router = createRouter({
  history: createWebHistory('/console'),
  routes,
});

// 记录已添加的路由，避免重复添加
let routesAdded = false;
// 标记是否正在添加路由，避免重复添加
let isAddingRoutes = false;
// 记录路由守卫的调用次数，防止无限循环
let navigationGuardCallCount = 0;
const MAX_NAVIGATION_GUARD_CALLS = 10;
// 路由添加后的等待时间（毫秒）
const ROUTE_ADD_WAIT_TIME = 50;

// 功能路由列表（这些路由不在菜单中，但应该允许访问）
const FUNCTIONAL_ROUTES = [
  '/homepage/rightsManage/addMember',
  '/homepage/systemManage/addRole',
];

// 检查用户是否有权限访问指定路由
function checkRoutePermission(routePath, menuTree) {
  if (!menuTree || !Array.isArray(menuTree)) {
    return false;
  }
  
  // 递归检查菜单树
  for (const menu of menuTree) {
    // 检查当前菜单的路径是否匹配
    if (menu.menu_path === routePath) {
      return true;
    }
    
    // 递归检查子菜单
    if (menu.children && menu.children.length > 0) {
      if (checkRoutePermission(routePath, menu.children)) {
        return true;
      }
    }
  }
  
  return false;
}

// 检查路由是否已匹配
function isRouteMatched(path) {
  try {
    const resolved = router.resolve(path);
    return resolved && resolved.matched && resolved.matched.length > 0;
  } catch (error) {
    return false;
  }
}

// 添加功能路由（不在菜单中但需要通过按钮触发的路由）
function addFunctionalRoutes(homepageRoute) {
  if (!homepageRoute?.children) {
    if (process.env.NODE_ENV === 'development') {
      console.warn('未找到 HomePage 路由或其子路由，无法添加功能路由');
    }
    return;
  }
  
  // 查找 rightsManage 路由
  const rightsManageRoute = homepageRoute.children.find(child => 
    child.name === 'rightsManage' || 
    child.path === 'rightsManage'
  );
  
  // if (rightsManageRoute) {
  //   addRouteIfNotExists('rightsManage', {
  //     path: 'addMember',
  //     name: 'addMember',
  //     component: () => import('@/views/rightsManage/AddMember'),
  //     meta: { menuName: '添加成员' }
  //   });
  // }
  
  // 查找 systemManage 路由
  const systemManageRoute = homepageRoute.children.find(child => 
    child.name === 'systemManage' || 
    child.path === 'systemManage'
  );
  
}

// 如果路由不存在则添加
function addRouteIfNotExists(parentRouteName, route) {
  const existingRoute = router.getRoutes().find(r => r.name === route.name);
  if (!existingRoute) {
    router.addRoute(parentRouteName, route);
    if (process.env.NODE_ENV === 'development') {
      console.log(`手动添加 ${route.name} 路由到 ${parentRouteName}`);
    }
  }
}

// 等待路由添加完成并重新匹配路由
async function waitForRoutesAndRematch(to, next) {
  // 等待路由添加完成，并等待 Vue Router 内部更新
  await new Promise(resolve => setTimeout(resolve, ROUTE_ADD_WAIT_TIME));
  
  // 路由添加后，强制重新匹配当前路由
  if (process.env.NODE_ENV === 'development') {
    console.log('路由守卫：路由添加完成，重新匹配路由:', to.path);
  }
  next(to);
}

// 动态添加路由
function addMenuRoutes(menuTree) {
  // 如果正在添加路由，直接返回，避免重复添加
  if (isAddingRoutes) {
    console.log('路由正在添加中，跳过重复添加');
    return;
  }
  
  // 检查路由是否真的存在（页面刷新后路由会被清空，但 routesAdded 标志可能仍然是 true）
  // 每次都检查路由是否真的存在，而不是依赖 routesAdded 标志
    const homepageRoute = router.getRoutes().find(route => route.name === 'HomePage');
  const hasDynamicRoutes = homepageRoute?.children?.length > 0;
    
  if (hasDynamicRoutes && routesAdded) {
    if (process.env.NODE_ENV === 'development') {
      console.log('路由已添加，跳过重复添加');
    }
      return;
  }
  
  // 如果路由不存在，重置标志
  if (!hasDynamicRoutes && routesAdded) {
    if (process.env.NODE_ENV === 'development') {
      console.log('检测到路由已清空（可能是页面刷新），重置 routesAdded 标志并重新添加路由');
    }
    routesAdded = false;
  }
  
  // 设置正在添加路由的标志
  isAddingRoutes = true;
  
  if (!menuTree || !Array.isArray(menuTree) || menuTree.length === 0) {
    console.warn('菜单树为空，无法添加路由');
    isAddingRoutes = false;
    return;
  }
  
  try {
    if (process.env.NODE_ENV === 'development') {
    console.log('addMenuRoutes: 开始处理菜单树', {
      menuTreeType: Array.isArray(menuTree) ? 'array' : typeof menuTree,
        menuTreeLength: Array.isArray(menuTree) ? menuTree.length : 'N/A'
    });
    }
    
    // 生成路由配置
    const menuRoutes = generateRoutesFromMenus(menuTree);
    
    if (process.env.NODE_ENV === 'development') {
    console.log('addMenuRoutes: 生成的路由配置', {
      routesCount: menuRoutes.length,
      routes: menuRoutes.map(r => ({
        path: r.path,
        name: r.name,
          childrenCount: r.children?.length || 0
      }))
    });
    }
    
    if (menuRoutes.length === 0) {
      console.warn('未生成任何路由配置');
      return;
    }
    
    if (!homepageRoute) {
      console.error('未找到 HomePage 路由，无法添加子路由');
      return;
    }
    
    // 添加子路由到 HomePage
    menuRoutes.forEach(route => {
      if (process.env.NODE_ENV === 'development') {
      console.log('准备添加路由:', {
        path: route.path,
        name: route.name,
          childrenCount: route.children?.length || 0
      });
      }
      
      // 添加父路由（包含子路由）
      router.addRoute('HomePage', route);
      
      // 仅在开发环境验证路由是否已添加
      if (process.env.NODE_ENV === 'development') {
      const addedRoute = router.getRoutes().find(r => r.name === route.name);
      if (addedRoute) {
        console.log('路由添加成功:', {
          name: addedRoute.name,
          path: addedRoute.path,
            childrenCount: addedRoute.children?.length || 0
          });
      } else {
        console.warn('路由添加失败，未找到路由:', route.name);
        }
      }
    });
    
    // 手动添加功能路由（这些路由不在菜单数据中，但需要通过按钮触发）
    addFunctionalRoutes(homepageRoute);
        
    // 仅在开发环境输出详细日志
    if (process.env.NODE_ENV === 'development') {
    console.log('所有已注册的路由:', router.getRoutes().map(r => ({
      name: r.name,
      path: r.path,
      childrenCount: r.children?.length || 0
    })));
    }
    
    // 设置默认重定向到第一个菜单路由
    if (menuRoutes.length > 0 && !homepageRoute.children?.some(child => child.path === '')) {
      const firstRoute = menuRoutes[0];
      // 使用路由名称重定向（路由名称在 generateRoutesFromMenus 中已正确生成）
      const redirectTarget = firstRoute.name ? { name: firstRoute.name } : '/homepage';
      router.addRoute('HomePage', {
        path: '',
        name: 'homepageRedirect',
        redirect: redirectTarget
      });
      if (process.env.NODE_ENV === 'development') {
        console.log('设置首页重定向到:', redirectTarget);
      }
    }
    
    routesAdded = true;
    if (process.env.NODE_ENV === 'development') {
    console.log('动态路由添加完成，共添加', menuRoutes.length, '个路由');
    }
  } catch (error) {
    console.error('添加动态路由失败:', error);
  } finally {
    // 重置正在添加路由的标志
    isAddingRoutes = false;
  }
}

// 动态添加单个菜单的子路由
export function addMenuChildrenRoutes(parentMenu) {
  if (!parentMenu || !parentMenu.children || !Array.isArray(parentMenu.children) || parentMenu.children.length === 0) {
    console.warn('菜单没有子菜单，无法添加子路由', parentMenu);
    return;
  }
  
  try {
    console.log('开始为菜单添加子路由:', {
      menuName: parentMenu.menu_name,
      menuPath: parentMenu.menu_path,
      childrenCount: parentMenu.children.length
    });
    
    // 生成子路由配置
    const parentPath = parentMenu.menu_path || '';
    const childRoutes = generateRoutesFromMenus(parentMenu.children, parentPath);
    
    if (childRoutes.length === 0) {
      console.warn('未生成任何子路由配置');
      return;
    }
    
    // 查找父路由
    // 方式1：通过 menuId 查找（最可靠）
    let parentRoute = router.getRoutes().find(r => r.meta?.menuId === parentMenu.id);
    
    // 方式2：如果方式1失败，通过路由名称查找
    if (!parentRoute) {
      const parentRouteName = parentMenu.menu_path?.split('/').pop() || '';
      parentRoute = router.getRoutes().find(r => r.name === parentRouteName);
    }
    
    // 方式3：如果方式2也失败，通过路径查找
    if (!parentRoute && parentMenu.menu_path) {
      const parentPath = parentMenu.menu_path.replace('/homepage/', '');
      parentRoute = router.getRoutes().find(r => r.path === parentPath || r.path === `/${parentPath}`);
    }
    
    if (!parentRoute) {
      console.warn('未找到父路由，无法添加子路由', {
        menuId: parentMenu.id,
        menuName: parentMenu.menu_name,
        menuPath: parentMenu.menu_path,
        allRoutes: router.getRoutes().map(r => ({ name: r.name, path: r.path, menuId: r.meta?.menuId }))
      });
      return;
    }
    
    console.log('找到父路由:', {
      name: parentRoute.name,
      path: parentRoute.path,
      existingChildrenCount: parentRoute.children?.length || 0
    });
    
    // 检查子路由是否已存在
    const existingChildNames = (parentRoute.children || []).map(c => c.name);
    const newChildRoutes = childRoutes.filter(child => !existingChildNames.includes(child.name));
    
    if (newChildRoutes.length === 0) {
      console.log('所有子路由已存在，跳过添加');
      return;
    }
    
    // 添加新的子路由
    newChildRoutes.forEach(childRoute => {
      console.log('添加子路由:', {
        name: childRoute.name,
        path: childRoute.path,
        parentName: parentRoute.name
      });
      
      router.addRoute(parentRoute.name, childRoute);
      
      // 验证路由是否已添加
      const addedRoute = router.getRoutes().find(r => r.name === childRoute.name);
      if (addedRoute) {
        console.log('子路由添加成功:', childRoute.name);
      } else {
        console.warn('子路由添加失败:', childRoute.name);
      }
    });
    
    // 如果父路由没有重定向，设置重定向到第一个子路由
    if (!parentRoute.redirect && newChildRoutes.length > 0) {
      const firstChildName = newChildRoutes[0].name;
      if (firstChildName) {
        router.addRoute(parentRoute.name, {
          path: '',
          redirect: { name: firstChildName }
        });
        console.log('设置父路由重定向:', firstChildName);
      }
    }
    
    console.log('子路由添加完成，共添加', newChildRoutes.length, '个子路由');
  } catch (error) {
    console.error('添加子路由失败:', error);
  }
}

// 全局前置守卫：确保登录后菜单已加载并添加动态路由
router.beforeEach(async (to, from, next) => {
  // 如果访问登录页，直接放行并重置计数器
  if (to.path === '/login') {
    navigationGuardCallCount = 0;
    next();
    return;
  }
  
  // 防止无限循环：如果路由守卫被调用太多次，直接放行
  navigationGuardCallCount++;
  if (navigationGuardCallCount > MAX_NAVIGATION_GUARD_CALLS) {
    console.warn('路由守卫调用次数过多，可能存在循环，直接放行');
    navigationGuardCallCount = 0;
    next();
    return;
  }
  
  // 获取用户信息
  const accountInfo = store.state.user.accountInfo;
  const userId = accountInfo?.userId;
  
  // 如果没有用户ID，说明未登录，跳转到登录页
  if (!userId) {
    console.warn('未登录，跳转到登录页');
    next('/login');
    return;
  }
  
  // 如果访问首页相关路由，需要确保菜单已加载并添加动态路由
  if (to.path.startsWith('/homepage')) {
    // 如果路由正在添加中，等待完成
    if (isAddingRoutes) {
      if (process.env.NODE_ENV === 'development') {
        console.log('路由守卫：路由正在添加中，等待完成');
      }
      let waitCount = 0;
      while (isAddingRoutes && waitCount < 50) {
        await new Promise(resolve => setTimeout(resolve, 100));
        waitCount++;
      }
    }
    
    const menuTree = store.state.user.menuTree;
    const menuLoading = store.state.user.menuLoading;
    
    // 检查路由是否真的存在（页面刷新后路由会被清空）
    // 缓存 homepageRoute 查找结果，避免重复查找
    const homepageRoute = router.getRoutes().find(route => route.name === 'HomePage');
    const hasDynamicRoutes = homepageRoute?.children?.length > 0;
    
    // 如果菜单未加载且不在加载中，则获取菜单
    if ((!menuTree || menuTree.length === 0) && !menuLoading) {
      if (process.env.NODE_ENV === 'development') {
      console.log('路由守卫：检测到菜单未加载，开始获取菜单和权限');
      }
      try {
        // 获取完整的菜单树（包含所有子菜单和按钮权限）
        await store.dispatch('user/fetchAllButtonPermissions');
        
        // 从 store 中获取菜单树
        const loadedMenuTree = store.getters['user/menuTree'];
        
        // 添加动态路由
        if (loadedMenuTree && loadedMenuTree.length > 0) {
          addMenuRoutes(loadedMenuTree);
          await waitForRoutesAndRematch(to, next);
          return;
        }
        
        if (process.env.NODE_ENV === 'development') {
          console.log('路由守卫：菜单和权限加载完成，菜单数量:', loadedMenuTree?.length || 0);
          }
        
        // 处理路由导航
        await handleRouteNavigation(to, loadedMenuTree, next);
    } catch (error) {
        console.error('路由守卫：获取菜单或权限失败', error);
        // 接口失败，清除用户信息并跳转到登录页
        store.dispatch('clearAllState');
        window.$toast && window.$toast(error?.message || '获取菜单或权限失败，请重新登录');
        next('/login');
      }
    } else if (menuLoading) {
      // 菜单正在加载中，等待加载完成
      if (process.env.NODE_ENV === 'development') {
      console.log('路由守卫：菜单正在加载中，等待加载完成');
      }
      let waitCount = 0;
      while (store.state.user.menuLoading && waitCount < 50) {
        await new Promise(resolve => setTimeout(resolve, 100));
        waitCount++;
      }
      
      // 加载完成后添加动态路由
      const loadedMenuTree = store.state.user.menuTree;
      if (loadedMenuTree && loadedMenuTree.length > 0) {
        addMenuRoutes(loadedMenuTree);
        await waitForRoutesAndRematch(to, next);
          return;
        }
      
      // 处理路由导航
      await handleRouteNavigation(to, loadedMenuTree, next);
    } else {
      // 菜单已加载，确保路由已添加
      if (menuTree && menuTree.length > 0) {
        if (!hasDynamicRoutes) {
          // 路由不存在，重新添加（页面刷新后路由会被清空）
          if (process.env.NODE_ENV === 'development') {
          console.log('路由守卫：检测到菜单已加载但路由不存在，重新添加路由');
          }
          addMenuRoutes(menuTree);
          await waitForRoutesAndRematch(to, next);
          return;
        } else if (!routesAdded) {
          // 路由存在但标志未设置，设置标志
          routesAdded = true;
        }
      }
      
      // 处理路由导航
      await handleRouteNavigation(to, menuTree, next);
    }
  } else {
    // 其他路由直接放行
    // 重置计数器（非首页路由，说明导航正常）
    navigationGuardCallCount = 0;
    next();
  }
  
  // 导航成功后重置计数器（延迟重置，确保导航完成）
  // 注意：这里使用 setTimeout 是为了在导航完成后重置，避免影响正常的多次导航
  if (to.path !== '/login') {
    setTimeout(() => {
      navigationGuardCallCount = 0;
    }, 100);
  }
});

// 查找第一个有 menu_path 的菜单项（递归查找）
function findFirstMenuPath(menuTree) {
  if (!menuTree || !Array.isArray(menuTree) || menuTree.length === 0) {
    return null;
  }
  
  for (const menu of menuTree) {
    // 只处理菜单项类型（menu_type === 1），忽略功能按钮（menu_type === 2）
    if (menu.menu_type === 1 && menu.menu_path) {
      return menu.menu_path;
    }
    
    // 如果有子菜单，递归查找
    if (menu.children && Array.isArray(menu.children) && menu.children.length > 0) {
      const childPath = findFirstMenuPath(menu.children);
      if (childPath) {
        return childPath;
      }
    }
  }
  
  return null;
}

// 处理路由导航的辅助函数
async function handleRouteNavigation(to, menuTree, next) {
      // 如果访问的是 /homepage 根路径，重定向到第一个有权限的菜单
      if (to.path === '/homepage' || to.path === '/homepage/') {
    const firstMenuPath = findFirstMenuPath(menuTree);
    if (firstMenuPath) {
      if (process.env.NODE_ENV === 'development') {
          console.log('路由守卫：访问首页，重定向到第一个菜单:', firstMenuPath);
      }
      // 更新 sessionStorage，确保顶部导航栏正确选中菜单
      sessionStorage.setItem('lastSelectedMenu', firstMenuPath);
      // 使用 replace 避免在历史记录中留下记录
      next({ path: firstMenuPath, replace: true });
          return;
        }
      }
      
        // 如果是功能路由，直接放行
        if (FUNCTIONAL_ROUTES.includes(to.path)) {
          next();
          return;
        }
        
  // 检查用户是否有权限访问当前路由
  if (to.path.startsWith('/homepage') && to.path !== '/homepage' && to.path !== '/homepage/') {
    if (menuTree && menuTree.length > 0) {
          // 检查当前路径是否在用户的菜单权限中
      const hasPermission = checkRoutePermission(to.path, menuTree);
          if (!hasPermission) {
            // 没有权限，重定向到第一个有权限的菜单
        const firstMenuPath = findFirstMenuPath(menuTree);
        if (firstMenuPath) {
          if (process.env.NODE_ENV === 'development') {
              console.log('路由守卫：用户无权限访问', to.path, '，重定向到第一个菜单:', firstMenuPath);
          }
          // 更新 sessionStorage，确保顶部导航栏正确选中菜单
          sessionStorage.setItem('lastSelectedMenu', firstMenuPath);
          // 使用 replace 避免在历史记录中留下记录
          next({ path: firstMenuPath, replace: true });
              return;
            }
          }
        }
      }
      
      // 检查是否是父路由（rightsManage 或 systemManage）且需要重定向到子路由
      const routeName = to.name || '';
      const isParentRoute = routeName === 'rightsManage' || routeName === 'systemManage';
      
      if (isParentRoute) {
        // 查找对应的路由配置
        const parentRoute = router.getRoutes().find(r => r.name === routeName);
        
        if (parentRoute) {
          // 如果路由有重定向配置，让 Vue Router 自动处理
          if (parentRoute.redirect) {
        if (process.env.NODE_ENV === 'development') {
            console.log('路由守卫：父路由有重定向配置，让 Vue Router 自动处理');
        }
            next();
      } else if (parentRoute.children?.length > 0) {
            // 如果是父路由且有子路由，但没有重定向配置，手动重定向到第一个子路由
            const firstChild = parentRoute.children[0];
        if (firstChild?.name) {
          if (process.env.NODE_ENV === 'development') {
              console.log('路由守卫：检测到父路由，重定向到第一个子路由:', firstChild.name);
          }
          // 使用 replace 避免在历史记录中留下记录
          next({ name: firstChild.name, replace: true });
            } else {
              next();
            }
          } else {
            next();
          }
        } else {
      // 如果找不到路由，可能是路由还没有完全添加，直接放行让 Vue Router 处理
      next();
    }
  } else {
    // 路由添加后，需要重新匹配当前路由
    if (isRouteMatched(to.path)) {
      if (process.env.NODE_ENV === 'development') {
        console.log('路由守卫：路由已匹配，直接放行');
      }
          next();
    } else {
      // 路由未匹配，可能是刚添加的路由，使用 next(to) 重新匹配
      // 但需要避免循环，所以只在计数器允许的情况下使用
      if (navigationGuardCallCount <= 3) {
        if (process.env.NODE_ENV === 'development') {
          console.log('路由守卫：路由未匹配，重新匹配路由:', to.path);
        }
        next(to);
      } else {
        // 如果已经调用太多次，直接放行
        if (process.env.NODE_ENV === 'development') {
          console.log('路由守卫：避免循环，直接放行');
        }
        next();
      }
    }
  }
}

// Vue Router 4 已经自动处理了重复导航的问题，不需要手动捕获异常
// 但如果需要，可以在这里添加全局导航守卫

export default router;
